package org.wdcode.common.tools;

import java.math.BigDecimal;

import org.wdcode.common.constants.StringConstants;
import org.wdcode.common.log.WdLogs;
import org.wdcode.common.util.CommonUtil;

/**
 * 数据类型转换,对null和异常进行处理
 * @author WD
 * @since JDK6
 * @version 1.0 2009-08-25
 */
public final class Conversion {
	/**
	 * 转换Object到字符串,如果参数为null返回"",否则返回obj.toString().trim()
	 * @param obj 要转换为字符串的对象
	 * @return 转换后的字符串
	 */
	public final static String toString(Object obj) {
		return toString(obj, StringConstants.EMPTY);
	}

	/**
	 * 转换Object到字符串,如果参数为null返回str,否则返回obj.toString().trim()
	 * @param obj 要转换为字符串的对象
	 * @param defaultValue 默认值
	 * @return 转换后的字符串
	 */
	public final static String toString(Object obj, String defaultValue) {
		return CommonUtil.isEmpty(obj) ? defaultValue : obj.toString().trim();
	}

	/**
	 * 转换Object为int,obj必须为能转换成int的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static int toInt(Object obj) {
		return toInt(obj, 0);
	}

	/**
	 * 转换Object为int,obj必须为能转换成int的对象,如果转换失败将返回i
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static int toInt(Object obj, int defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return ((Number) obj).intValue();
			} else if (obj instanceof String) {
				// String
				return Integer.parseInt(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return ((Boolean) obj).booleanValue() ? 1 : 0;
			} else if (obj instanceof Character) {
				return ((Character) obj).charValue();
			} else {
				// 普通对象 转换成String 在返回
				return Integer.parseInt(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回num
			return defaultValue;
		}
	}

	/**
	 * 转换Object为long,obj必须为能转换成long的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static long toLong(Object obj) {
		return toLong(obj, 0);
	}

	/**
	 * 转换Object为long,obj必须为能转换成long的对象,如果转换失败将返回num
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static long toLong(Object obj, long defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return ((Number) obj).longValue();
			} else if (obj instanceof String) {
				// String
				return Long.parseLong(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return ((Boolean) obj).booleanValue() ? 1 : 0;
			} else if (obj instanceof Character) {
				return ((Character) obj).charValue();
			} else {
				// 普通对象 转换成String 在返回
				return Long.parseLong(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回defaultValue
			return defaultValue;
		}
	}

	/**
	 * 转换Object为float,obj必须为能转换成float的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static float toFloat(Object obj) {
		return toFloat(obj, 0);
	}

	/**
	 * 转换Object为float,obj必须为能转换成float的对象,如果转换失败将返回num
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static float toFloat(Object obj, float defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return ((Number) obj).floatValue();
			} else if (obj instanceof String) {
				// String
				return Float.parseFloat(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return ((Boolean) obj).booleanValue() ? 1 : 0;
			} else if (obj instanceof Character) {
				return ((Character) obj).charValue();
			} else {
				// 普通对象 转换成String 在返回
				return Float.parseFloat(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回num
			return defaultValue;
		}
	}

	/**
	 * 转换Object为double,obj必须为能转换成double的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static double toDouble(Object obj) {
		return toDouble(obj, 0);
	}

	/**
	 * 转换Object为double,obj必须为能转换成double的对象,如果转换失败将返回num
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static double toDouble(Object obj, double defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return ((Number) obj).doubleValue();
			} else if (obj instanceof String) {
				// String
				return Double.parseDouble(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return ((Boolean) obj).booleanValue() ? 1 : 0;
			} else if (obj instanceof Character) {
				return ((Character) obj).charValue();
			} else {
				// 普通对象 转换成String 在返回
				return Double.parseDouble(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回num
			return defaultValue;
		}
	}

	/**
	 * 转换Object为short,obj必须为能转换成short的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static short toShort(Object obj) {
		return toShort(obj, (short) 0);
	}

	/**
	 * 转换Object为short,obj必须为能转换成short的对象,如果转换失败将返回num
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static short toShort(Object obj, short defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return ((Number) obj).shortValue();
			} else if (obj instanceof String) {
				// String
				return Short.parseShort(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return (short) (((Boolean) obj).booleanValue() ? 1 : 0);
			} else if (obj instanceof Character) {
				return (short) (((Character) obj).charValue());
			} else {
				// 普通对象 转换成String 在返回
				return Short.parseShort(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回num
			return defaultValue;
		}
	}

	/**
	 * 转换Object为byte,obj必须为能转换成byte的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static byte toByte(Object obj) {
		return toByte(obj, (byte) 0);
	}

	/**
	 * 转换Object为byte,obj必须为能转换成byte的对象,如果转换失败将返回num
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static byte toByte(Object obj, byte defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return ((Number) obj).byteValue();
			} else if (obj instanceof String) {
				// String
				return Byte.parseByte(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return (byte) (((Boolean) obj).booleanValue() ? 1 : 0);
			} else if (obj instanceof Character) {
				return (byte) (((Character) obj).charValue());
			} else {
				// 普通对象 转换成String 在返回
				return Byte.parseByte(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回num
			return defaultValue;
		}
	}

	/**
	 * 转换Object为byte,obj必须为能转换成byte的对象,如果转换失败将返回0
	 * @param obj 要转换的对象
	 * @return 转换后的数字
	 */
	public final static BigDecimal toBigDecimal(Object obj) {
		return toBigDecimal(obj, BigDecimal.ZERO);
	}

	/**
	 * 转换Object为byte,obj必须为能转换成byte的对象,如果转换失败将返回num
	 * @param obj 要转换的对象
	 * @param defaultValue 默认值
	 * @return 转换后的数字
	 */
	public final static BigDecimal toBigDecimal(Object obj, BigDecimal defaultValue) {
		try {
			// 判断对象类型
			if (CommonUtil.isEmpty(obj)) {
				return defaultValue;
			} else if (obj instanceof Number) {
				// Number
				return BigDecimal.valueOf(((Number) obj).doubleValue());
			} else if (obj instanceof String) {
				// String
				return new BigDecimal(obj.toString());
			} else if (obj instanceof Boolean) {
				// Boolean
				return ((Boolean) obj).booleanValue() ? BigDecimal.ONE : BigDecimal.ZERO;
			} else if (obj instanceof Character) {
				return new BigDecimal(((Character) obj).charValue());
			} else {
				// 普通对象 转换成String 在返回
				return new BigDecimal(toString(obj));
			}
		} catch (RuntimeException re) {
			// 警告
			WdLogs.warn(re);
			// 如果失败返回num
			return defaultValue;
		}
	}

	/**
	 * 转换Object为boolean 转换失败或不能转换返回 false
	 * @param obj 转换为boolean的对象
	 * @return true false
	 */
	public final static boolean toBoolean(Object obj) {
		return toBoolean(obj, false);
	}

	/**
	 * 转换Object为boolean 转换失败或不能转换返回 defaultValue
	 * @param obj 转换为boolean的对象
	 * @param defaultValue 默认值
	 * @return true false
	 */
	public final static boolean toBoolean(Object obj, boolean defaultValue) {
		// 判断类型
		if (CommonUtil.isEmpty(obj)) {
			return defaultValue;
		} else if (obj instanceof Boolean) {
			// Boolean
			return ((Boolean) obj).booleanValue();
		} else if (obj instanceof String) {
			// String
			return StringConstants.TRUE.equalsIgnoreCase(obj.toString()) || StringConstants.YES.equalsIgnoreCase(obj.toString()) || StringConstants.OK.equalsIgnoreCase(obj.toString());
		} else if (obj instanceof Number) {
			// Number
			return ((Number) obj).intValue() > 0 ? true : false;
		} else {
			// 其它类型先转换成String 在转成Boolean
			return Boolean.parseBoolean(toString(obj));
		}
	}

	/**
	 * 如果str等于""返回null,否则返回它本身
	 * @param str 要对比的字符串
	 * @return 比较后的字符串
	 */
	public final static String stringToNull(String str) {
		return stringToNull(str, StringConstants.EMPTY);
	}

	/**
	 * 如果str等于eq返回null,否则返回它本身
	 * @param str 要对比的字符串
	 * @param eq 对比字符串
	 * @return 比较后的字符串
	 */
	public final static String stringToNull(String str, String eq) {
		return toString(eq).equals(str) ? null : str;
	}

	/*
	 * 私有构造，禁止外部实例化
	 */
	private Conversion() {}
}
